/**
 * JZ UnoCSS - 工具函数模块 (uvue专用)
 * @version 1.1.0
 * @author jz
 */

// 工具函数
export const utils = {
    detectPlatform() {
        if (typeof process !== 'undefined' && process.env && process.env.UNI_PLATFORM) {
            return process.env.UNI_PLATFORM.toUpperCase().replace(/-/g, '-');
        }
        
        // 运行时平台检测
        if (typeof uni !== 'undefined') {
            const systemInfo = uni.getSystemInfoSync();
            if (systemInfo.platform === 'android' || systemInfo.platform === 'ios') {
                return 'APP-PLUS';
            }
        }
        
        // 浏览器环境检测
        if (typeof window !== 'undefined') {
            // 检测是否为微信小程序webview
            if (window.__wxjs_environment === 'miniprogram') {
                return 'MP-WEIXIN';
            }
            // 检测是否为支付宝小程序
            if (window.my && window.my.env) {
                return 'MP-ALIPAY';
            }
            // 其他情况认为是H5
            return 'H5';
        }
        
        return 'APP-PLUS';  // uvue 默认为 APP-PLUS 平台
    },

    // 检测文件类型 - 只处理 uvue 文件
    detectFileType(filePath) {
        if (!filePath) return 'uvue';
        
        const extension = filePath.split('.').pop()?.toLowerCase();
        
        // 只处理 uvue 文件
        if (extension === 'uvue') {
            return 'uvue';
        }
        
        // 其他文件类型不处理
        return null;
    },

    // 检查平台是否支持特定的CSS类名或功能
    isPlatformSupported(className, platform, fileType) {
        // 基本的平台支持检查
        const supportedPlatforms = [
            'H5', 'MP-WEIXIN', 'MP-ALIPAY', 'MP-BAIDU', 'MP-TOUTIAO', 'MP-QQ', 
            'MP-KUAISHOU', 'MP-JINGDONG', 'APP-PLUS', 'APP-ANDROID', 'APP-IOS',
            'QUICKAPP-WEBVIEW', 'QUICKAPP-WEBVIEW-UNION', 'QUICKAPP-WEBVIEW-HUAWEI'
        ];
        
        if (!supportedPlatforms.includes(platform)) {
            return false;
        }

        // APP平台的限制（uni-app-x APP端）
        // 参考：https://doc.dcloud.net.cn/uni-app-x/css/
        if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
            // APP端不支持直接的百分号类名（如 w-50%），但支持方括号语法中的百分号（如 w-[89%]）
            if (className && className.includes('%') && !className.includes('[')) {
                return false;
            }
            
            // APP端不支持的CSS属性或类名模式
            const unsupportedPatterns = [
                /backdrop-/, // backdrop滤镜
                /filter-/, // CSS滤镜
                /transition-(?!duration|delay|timing|property)/, // 大部分transition属性
                /animate-/, // CSS动画
                /scroll-/, // 滚动相关
                /touch-/, // 触摸相关
                /select-/, // 文本选择
                /pointer-events/, // 指针事件
                /user-select/, // 用户选择
                /sticky/, // position: sticky
                /fixed/, // position: fixed 在某些情况下不支持
                /-/, // CSS  布局
                /table-/, // Table 布局
                /inline-/, // inline 相关布局
            ];
            
            if (className && unsupportedPatterns.some(pattern => pattern.test(className))) {
                return false;
            }
        }

        // 小程序平台的限制
        if (platform.startsWith('MP-')) {
            // 小程序不支持的CSS属性
            const unsupportedInMiniProgram = [
                /backdrop-/, // backdrop滤镜
                /filter-/, // CSS滤镜
                /clip-path/, // 裁剪路径
                /mask-/, // 遮罩
                /sticky/, // position: sticky
            ];
            
            if (className && unsupportedInMiniProgram.some(pattern => pattern.test(className))) {
                return false;
            }
        }

        // H5平台支持完整的CSS
        if (platform === 'H5') {
            return true;
        }

        return true;
    },

    isNumber(value) {
        return /^-?(\d*\.?\d+)$/.test(value);
    },

    // 解码类名中的特殊字符
    decodeClassName(className) {
        if (!className) return className;
        
        // 处理HTML实体编码 &#37; -> %
        let decoded = className.replace(/&#37;/g, '%');
        
        // 处理URL编码 %25 -> %
        try {
            decoded = decodeURIComponent(decoded);
        } catch (e) {
            // 如果解码失败，返回原值
        }
        
        return decoded;
    },

    // uvue 兼容性：将特殊字符转换为安全字符（用于HTML类名）
    encodeClassNameForUvue(className) {
        if (!className) return className;
        
        // 确保只处理有效的类名，避免处理JavaScript表达式
        // 更精确的验证：排除明显的JavaScript表达式
        if (
            /\s/.test(className) ||  // 包含空格
            /[=><]/.test(className) || // 包含比较运算符
            // 修复：排除CSS类名中的数字小数点，只匹配真正的对象属性访问
            (/^[a-zA-Z_$][a-zA-Z0-9_$]*\.[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(className) && !/\[.*\]/.test(className)) || // 属性访问，如 item.key（但允许方括号语法）
            (/\(/.test(className) && !/\[.*\(.*\).*\]/.test(className)) // 函数调用，但允许方括号内的括号
        ) {
            return className;
        }
        
        // 将 / 转换为 M，例如：w-1/2 -> w-1M2
        // 将 % 转换为 P，例如：w-50% -> w-50P
        // 将 [ 转换为 L，例如：text-[24rpx] -> text-L24rpxR
        // 将 ] 转换为 R，例如：text-[24rpx] -> text-L24rpxR
        // 将 # 转换为 S，例如：text-[#333] -> text-LS333R
        // 将 ( 转换为 O，例如：bg-[rgb(255,0,0)] -> bg-LrgbO255,0,0CR
        // 将 ) 转换为 C，例如：bg-[rgb(255,0,0)] -> bg-LrgbO255,0,0CR
        // 将 , 转换为 K，例如：bg-[rgb(255,0,0)] -> bg-LrgbO255K0K0CR
        // 将 . 转换为 D，例如：text-[1.5rem] -> text-L1D5remR
        return className
            .replace(/\[/g, 'L')
            .replace(/\]/g, 'R')
            .replace(/#/g, 'S')
            .replace(/\(/g, 'O')
            .replace(/\)/g, 'C')
            .replace(/,/g, 'K')
            .replace(/\./g, 'D')
            .replace(/\//g, 'M')
            .replace(/%/g, 'P');
    },

    // uvue 兼容性：将安全字符转换回特殊字符（用于CSS生成）
    decodeClassNameFromUvue(className) {
        if (!className) return className;
        
        // 确保只处理有效的类名，避免处理JavaScript表达式
        if (
            /\s/.test(className) ||  // 包含空格
            /[=><]/.test(className) || // 包含比较运算符
            // 修复：排除CSS类名中的数字小数点，只匹配真正的对象属性访问
            (/^[a-zA-Z_$][a-zA-Z0-9_$]*\.[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(className) && !/\[.*\]/.test(className)) || // 属性访问，如 item.key（但允许方括号语法）
            (/\(/.test(className) && !/\[.*\(.*\).*\]/.test(className)) // 函数调用，但允许方括号内的括号
        ) {
            return className;
        }
        
        // 将编码字符转换回原始字符
        // L -> [, R -> ], S -> #, O -> (, C -> ), K -> ,, D -> ., M -> /, P -> %
        return className
            .replace(/L/g, '[')
            .replace(/R/g, ']')
            .replace(/S/g, '#')
            .replace(/O/g, '(')
            .replace(/C/g, ')')
            .replace(/K/g, ',')
            .replace(/D/g, '.')
            .replace(/M/g, '/')
            .replace(/(\d+(?:\.\d+)?)P(?=\b|$)/g, '$1%');
    },

    // 检测类名是否包含特殊字符（需要转换）
    hasSpecialChars(className) {
        // 如果是JavaScript表达式，不是CSS类名
        if (
            /\s/.test(className) ||  // 包含空格
            /[=><]/.test(className) || // 包含比较运算符
            // 修复：排除CSS类名中的数字小数点，只匹配真正的对象属性访问
            (/^[a-zA-Z_$][a-zA-Z0-9_$]*\.[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(className) && !/\[.*\]/.test(className)) || // 属性访问，如 item.key（但允许方括号语法）
            (/\(/.test(className) && !/\[.*\(.*\).*\]/.test(className)) // 函数调用，但允许方括号内的括号
        ) {
            return false;
        }
        return /[/\[\]#(),%.]/.test(className);
    },

    // 检测类名是否包含百分号（需要转换）
    hasPercentage(className) {
        return /\d+%/.test(className);
    },

    // 检测类名是否包含分数符号（需要转换）
    hasFraction(className) {
        return /\//.test(className);
    },

    // 检测类名是否包含方括号语法（需要转换）
    hasBracketSyntax(className) {
        return /\[.*?\]/.test(className);
    },

    // 检测类名是否包含颜色值（需要转换）
    hasColorValue(className) {
        return /[#(),]/.test(className);
    },

    generateValue(value, unit = 'rpx') {
        if (!value) return '';
        if (this.isNumber(value) && parseFloat(value) !== 0) {
            return `${value}${unit}`;
        }
        return value;
    },

    toRgb(color) {
        if (!color) return '';
        color = color.toString().trim().toLowerCase().replace('#', '');
        
        if (!/^[0-9a-f]+$/i.test(color) || ![3, 6].includes(color.length)) {
            return color;
        }
        
        if (color.length === 3) {
            color = color.split('').map(c => c + c).join('');
        }
        
        const r = parseInt(color.substr(0, 2), 16);
        const g = parseInt(color.substr(2, 2), 16);
        const b = parseInt(color.substr(4, 2), 16);
        
        return `${r},${g},${b}`;
    },

    // 条件编译处理 - 支持多平台
    processConditionalCompilation(code, platform) {
        const platformMap = {
            'H5': 'H5',
            'MP-WEIXIN': 'MP-WEIXIN',
            'MP-ALIPAY': 'MP-ALIPAY', 
            'MP-BAIDU': 'MP-BAIDU',
            'MP-TOUTIAO': 'MP-TOUTIAO',
            'MP-QQ': 'MP-QQ',
            'MP-KUAISHOU': 'MP-KUAISHOU',
            'MP-JINGDONG': 'MP-JINGDONG',
            'APP-PLUS': 'APP-PLUS',
            'APP-ANDROID': 'APP-PLUS',
            'APP-IOS': 'APP-PLUS',
            'APP-PLUS-NVUE': 'APP-PLUS',
            'QUICKAPP-WEBVIEW': 'QUICKAPP-WEBVIEW',
            'QUICKAPP-WEBVIEW-UNION': 'QUICKAPP-WEBVIEW',
            'QUICKAPP-WEBVIEW-HUAWEI': 'QUICKAPP-WEBVIEW'
        };

        const currentPlatform = platformMap[platform] || platform;
        
        // 处理 #ifdef 和 #ifndef 条件编译
        let processedCode = code;
        
        // 匹配条件编译块
        const conditionalRegex = /\/\*\s*#(ifdef|ifndef)\s+([^*]+)\s*\*\/([\s\S]*?)\/\*\s*#endif\s*\*\//g;
        
        processedCode = processedCode.replace(conditionalRegex, (match, directive, condition, content) => {
            const conditions = condition.trim().split(/\s*\|\|\s*/);
            const shouldInclude = directive === 'ifdef' 
                ? conditions.includes(currentPlatform)
                : !conditions.includes(currentPlatform);
            
            return shouldInclude ? content : '';
        });

        return processedCode;
    },

    // 平台特定的单位转换 - 支持多平台（只处理uvue文件）
    // 修复：正确的数值转换逻辑
    convertUnit(value, platform, options = {}) {
        if (!this.isNumber(value)) return value;
        
        const { h5Unit = 'rem', remBase = 16, unitType = 'spacing' } = options;
        const numValue = parseFloat(value);
        
        // H5平台单位转换
        if (platform === 'H5') {
            if (h5Unit === 'rem') {
                if (unitType === 'spacing' || unitType === 'sizing') {
                    // 修复：UnoCSS标准：1 = 0.25rem，所以数值直接 * 0.25
                    // 例如：p-4 = 4 * 0.25 = 1rem, h-32 = 32 * 0.25 = 8rem
                    // 但这样太大了，改为更合理的比例：1 = 0.0625rem (1px/16px)
                    const remValue = numValue * 0.0625; // 1px = 0.0625rem
                    return `${remValue}rem`;
                } else if (unitType === 'fontSize') {
                    // 字体大小直接转换：18 = 1.125rem (18/16)
                    const remValue = numValue / remBase;
                    return `${remValue}rem`;
                } else {
                    // 其他情况使用合理的转换
                    const remValue = numValue / remBase;
                    return `${remValue}rem`;
                }
            } else if (h5Unit === 'px') {
                if (unitType === 'spacing' || unitType === 'sizing') {
                    // spacing和sizing：直接使用数值作为px
                    return `${numValue}px`;
                } else {
                    // 字体大小等直接使用数值
                    return `${numValue}px`;
                }
            } else if (h5Unit === 'vw') {
                // 假设设计稿为750px宽度
                const baseValue = (unitType === 'spacing' || unitType === 'sizing') ? numValue : numValue;
                const vwValue = (baseValue / 750) * 100;
                return `${vwValue}vw`;
            }
            return `${value}${h5Unit}`;
        }
        
        // 小程序平台单位转换
        if (platform.startsWith('MP-')) {
            if (unitType === 'spacing' || unitType === 'sizing') {
                // spacing和sizing：直接使用数值作为rpx，更合理
                return `${numValue * 2}rpx`; // 适当放大一点
            } else {
                // 字体大小等直接使用数值
                return `${numValue}rpx`;
            }
        }
        
        // APP平台（uvue编译到APP）
        if (platform === 'APP-PLUS' || platform === 'APP-ANDROID' || platform === 'APP-IOS') {
            if (unitType === 'spacing' || unitType === 'sizing') {
                // spacing和sizing：直接使用数值作为rpx，更合理
                return `${numValue * 2}rpx`; // 适当放大一点
            } else {
                // 字体大小等直接使用数值
                return `${numValue}rpx`;
            }
        }
        
        // 其他平台默认使用rpx
        if (unitType === 'spacing' || unitType === 'sizing') {
            return `${numValue * 2}rpx`; // 适当放大一点，但不要太大
        } else {
            return `${numValue}rpx`;
        }
    }
}; 